www.gusucode.com > VC++ 视频采集与压缩、音频采集、加扰和解绕-源码程序 > VC++ 视频采集与压缩、音频采集、加扰和解绕-源码程序/code/VideoNet_src/AES_Scrambler.cpp

    //Download by http://www.NewXing.com
#include "Stdafx.h"

#include "AES_Scrambler.h"
 
#include "stdio.h" 


 #define LARGE_TABLE
; 
 u1byte pow_tab[256];
 u1byte log_tab[256];
 u1byte sbx_tab[256];
 u1byte isb_tab[256];
 u4byte rco_tab[10];
 u4byte ft_tab[4][256];
 u4byte it_tab[4][256];
 
 #ifdef LARGE_TABLE
 u4byte fl_tab[4][256];
 u4byte il_tab[4][256];
 #endif

 u4byte tab_gen=0;
 
 u4byte k_len;
 u4byte e_key[60];
 u4byte d_key[60];
 
 #define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a]+log_tab[b])%255]:0)
 
 #define byte(x,n) ((u1byte)((x)>>(8*n)))
 
 #define f_rn(bo,bi,n,k)             \
  bo[n]=ft_tab[0][byte(bi[n],0)]^   \
   ft_tab[1][byte(bi[(n+1)&3], 1)]^   \
   ft_tab[2][byte(bi[(n+2)&3], 2)]^   \
   ft_tab[3][byte(bi[(n+3)&3], 3)]^ *(k+n)
   
 #define i_rn(bo,bi,n,k)               \
  bo[n]=it_tab[0][byte(bi[n],0)]^   \
   it_tab[1][byte(bi[(n+3)&3], 1)]^   \
   it_tab[2][byte(bi[(n+2)&3], 2)]^   \
   it_tab[3][byte(bi[(n+1)&3], 3)]^ *(k+n) 
 
 #define rotr(x,n) (((x)>>((int)(n))) | ((x)<<(32-(int)(n))))
 #define rotl(x,n) (((x)<<((int)(n))) | ((x)>>(32-(int)(n))))
 
 #ifdef LARGE_TABLES
 #define ls_box(x)     \
 (fl_tab[0][byte(x,0)]^fl_tab[1][byte(x,1)]^ \
 fl_tab[2][byte(x,2)]^fl_tab[3][byte(x,3)])
 
 #define f_rl(bo,bi,n,k)              \
  bo[n]=fl_tab[0][byte(bi[n],0)]^   \
   fl_tab[1][byte(bi[(n+1)&3], 1)]^   \
   fl_tab[2][byte(bi[(n+2)&3], 2)]^   \
   fl_tab[3][byte(bi[(n+3)&3], 3)]^ *(k+n)
   
 #define i_rn(bo,bi,n,k)              \
  bo[n]=il_tab[0][byte(bi[n],0)]^   \
   il_tab[1][byte(bi[(n+3)&3], 1)]^   \
   il_tab[2][byte(bi[(n+2)&3], 2)]^   \
   il_tab[3][byte(bi[(n+1)&3], 3)]^ *(k+n) 
 #else
 
 #define ls_box(x)           \
 ((u4byte)sbx_tab[byte(x,0)]<<0)^((u4byte)sbx_tab[byte(x,1)]<<8)^ \
 ((u4byte)sbx_tab[byte(x,2)]<<16)^((u4byte)sbx_tab[byte(x,3)]<<24)
 
 #define f_rl(bo,bi,n,k)                 \
  bo[n]=(u4byte)sbx_tab[byte(bi[n],0)] ^ \
  rotl(((u4byte)sbx_tab[byte(bi[(n+1)&3],1)]),8) ^  \
  rotl(((u4byte)sbx_tab[byte(bi[(n+2)&3],2)]),16) ^  \
  rotl(((u4byte)sbx_tab[byte(bi[(n+3)&3],3)]),24) ^*(k+n)

 #define i_rl(bo,bi,n,k)                 \
  bo[n]=(u4byte)isb_tab[byte(bi[n],0)] ^ \
  rotl(((u4byte)isb_tab[byte(bi[(n+3)&3],1)]),8) ^  \
  rotl(((u4byte)isb_tab[byte(bi[(n+2)&3],2)]),16) ^  \
  rotl(((u4byte)isb_tab[byte(bi[(n+1)&3],3)]),24) ^*(k+n)
 #endif


 #define star_x(x)  (((x)& 0x7f7f7f7f)<<1)^((((x) & 0x80808080)>>7)*0x1b)
 
 #define imix_col(y,x) \
 u=star_x(x); v=star_x(u); w=star_x(v);\
 t=w^(x); (y)=u^v^w; (y)^=rotr(u^t,8)^rotr(v^t,16)^rotr(t,24)
 

 
 #define loop6(i)     \
 { t=ls_box(rotl(t,8))^rotr(rco_tab[i], 8);\
   t^=e_key[6*i];     e_key[6*i+6]=t; \
   t^=e_key[6*i+1];     e_key[6*i+7]=t; \
   t^=e_key[6*i+2];     e_key[6*i+8]=t; \
   t^=e_key[6*i+3];     e_key[6*i+9]=t; \
   t^=e_key[6*i+4];     e_key[6*i+10]=t; \
   t^=e_key[6*i+5];     e_key[6*i+11]=t; \
 }
 
 #define loop8(i)     \
 { t=ls_box(rotl(t,8))^rotr(rco_tab[i], 8);\
   t^=e_key[8*i];     e_key[8*i+8]=t; \
   t^=e_key[8*i+1];     e_key[8*i+9]=t; \
   t^=e_key[8*i+2];     e_key[8*i+10]=t; \
   t^=e_key[8*i+3];     e_key[8*i+11]=t; \
   t^=e_key[8*i+4]^ls_box(t);  e_key[8*i+12]=t; \
   t^=e_key[8*i+5];     e_key[8*i+13]=t; \
     t^=e_key[8*i+6];     e_key[8*i+14]=t; \
   t^=e_key[8*i+7];     e_key[8*i+15]=t; \
 } 
 #define f_nround(bo, bi, k) \
 f_rn(bo, bi, 0, k); f_rn(bo, bi, 1, k); \
 f_rn(bo, bi, 2, k); f_rn(bo, bi, 3, k); k+=4
 
 #define f_lround(bo, bi, k) \
 f_rl(bo, bi, 0, k); f_rl(bo, bi, 1, k); f_rl(bo, bi, 2, k); f_rl(bo, bi, 3, k)
 #define i_nround(bo, bi, k) \
 i_rn(bo, bi, 0, k); i_rn(bo, bi, 1, k); \
 i_rn(bo, bi, 2, k); i_rn(bo, bi, 3, k); k-=4
 
 #define i_lround(bo, bi, k) \
 i_rl(bo, bi, 0, k); i_rl(bo, bi, 1, k); i_rl(bo, bi, 2, k); i_rl(bo, bi, 3, k)



void AesScrambler::gen_tabs(void)
 { 
	u4byte i, t;
	u1byte p, q;
   
	for(i=0, p=1; i<256; ++i)
	{
		pow_tab[i]=(u1byte)p; log_tab[p]=(u1byte)i;
		p=p^(p<<1)^(p & 0x80 ? 0x1b :0);
	}
 
	log_tab[1]=0; p=1;
 
	for(i=0; i<10; ++i)
	{
		rco_tab[i]=p;
		p=(p<<1)^(p & 0x80 ? 0x1b :0);
	}
 
	for(i=0; i<256; ++i)
	{
		p=(i? pow_tab[255-log_tab[i]]: 0); q=p;
		q=(q>>7) | (q<<1); p^=q;
		q=(q>>7) | (q<<1); p^=q;
		q=(q>>7) | (q<<1); p^=q;
		q=(q>>7) | (q<<1); p^=q^0x63;
		sbx_tab[i]=(u1byte)p; isb_tab[p]=(u1byte)i;
	}
 
	for(i=0; i<256; ++i)
	{
		p=sbx_tab[i];
    
		#ifdef LARGE_TABLES
			t=p; 
			f1_tab[0][i]=t;
			f1_tab[1][i]=rot1(t, 8);
			f1_tab[2][i]=rot1(t, 16);
			f1_tab[3][i]=rot1(t, 24);
		#endif
		
		t=((u4byte)ff_mult(2,p))|((u4byte)p<<8)|
			((u4byte)p<<16)|((u4byte)ff_mult(3,p)<<24);
  
		ft_tab[0][i]=t; 
		ft_tab[1][i]=rotl(t,8);
		ft_tab[2][i]=rotl(t,16);
		ft_tab[3][i]=rotl(t,24);
  
		p=isb_tab[i];
  
		#ifdef LARGE_TABLES
			t=p;
			il_tab[0][i]=t; 
			il_tab[1][i]=rotl(t,8); 
			il_tab[2][i]=rotl(t,16);
			il_tab[3][i]=rotl(t,24);
		#endif

		t=((u4byte)ff_mult(14,p))|((u4byte)ff_mult(9,p)<<8)|
			((u4byte)ff_mult(13,p)<<16)|((u4byte)ff_mult(11,p)<<24);
  
	  it_tab[0][i]=t; 
	  it_tab[1][i]=rotl(t,8);
	  it_tab[2][i]=rotl(t,16);
	  it_tab[3][i]=rotl(t,24);
	}
	tab_gen=1;
 }
 
void AesScrambler::set_key(const u4byte in_key[], const u4byte key_len)
 { u4byte i, t, u, v, w;
 
   if(!tab_gen)
   gen_tabs();
   
   k_len=(key_len+31)/32;
   
   e_key[0]=in_key[0]; e_key[1]=in_key[1];
   e_key[2]=in_key[2]; e_key[3]=in_key[3];
   
   switch(k_len)
   {
     case 4: t=e_key[3];
     for(i=0; i<10; ++i)
	  { t=ls_box(rotr(t,8))^rco_tab[i];
		 t^=e_key[4*i];     e_key[4*i+4]=t; 
		 t^=e_key[4*i+1];     e_key[4*i+5]=t; 
		 t^=e_key[4*i+2];     e_key[4*i+6]=t; 
		 t^=e_key[4*i+3];     e_key[4*i+7]=t; 
	  };
     break;
     
     case 6: e_key[4]=in_key[4]; t=e_key[5]=in_key[5];
     for(i=0; i<8; ++i)
     loop6(i);
     break;
     
     case 8: e_key[4]=in_key[4]; e_key[5]=in_key[5];
     e_key[6]=in_key[6]; t=e_key[7]=in_key[7];
     for(i=0; i<7; ++i)
     loop8(i);
     break;
   }
   
   d_key[0]=e_key[0]; d_key[1]=e_key[1];
   d_key[2]=e_key[2]; d_key[3]=e_key[3];
   
   for(i=4; i<4*k_len+24; ++i)
   {  imix_col(d_key[i], e_key[i]);
   }
   }
     


void AesScrambler::encrypt(const u4byte in_blk[4], u4byte out_blk[4])
 { u4byte b0[4], b1[4], *kp;

   b0[0]=in_blk[0]^e_key[0]; b0[1]=in_blk[1]^e_key[1];
   b0[2]=in_blk[2]^e_key[2]; b0[3]=in_blk[3]^e_key[3];

   kp=e_key+4;

   if(k_len>6)
   { f_nround(b1, b0, kp);  f_nround(b0, b1, kp); 
   }

   if(k_len>4)
   { f_nround(b1, b0, kp);  f_nround(b0, b1, kp); 
   }

   f_nround(b1, b0, kp);  
   f_nround(b0, b1, kp); 
   f_nround(b1, b0, kp);  f_nround(b0, b1, kp); 
   f_nround(b1, b0, kp);  f_nround(b0, b1, kp); 
      f_nround(b1, b0, kp);  f_nround(b0, b1, kp); 
      f_nround(b1, b0, kp);  
   f_lround(b0, b1, kp);  

   out_blk[0]=b0[0]; out_blk[1]=b0[1]; 
   out_blk[2]=b0[2]; out_blk[3]=b0[3]; 
 }

 
void AesScrambler::decrypt(const u4byte in_blk[4], u4byte out_blk[4])
 { u4byte b0[4], b1[4], *kp;

   b0[0]=in_blk[0]^e_key[4*k_len+24]; b0[1]=in_blk[1]^e_key[4*k_len+25];
   b0[2]=in_blk[2]^e_key[4*k_len+26]; b0[3]=in_blk[3]^e_key[4*k_len+27];

   kp=d_key+4*(k_len+5);

   if(k_len>6)
   { i_nround(b1, b0, kp);  i_nround(b0, b1, kp); 
   }

   if(k_len>4)
   { i_nround(b1, b0, kp);  i_nround(b0, b1, kp); 
   }

   i_nround(b1, b0, kp);  
   i_nround(b0, b1, kp); 
   i_nround(b1, b0, kp);  i_nround(b0, b1, kp); 
   i_nround(b1, b0, kp);  i_nround(b0, b1, kp); 
      i_nround(b1, b0, kp);  i_nround(b0, b1, kp); 
      i_nround(b1, b0, kp);  
   i_lround(b0, b1, kp);  

   out_blk[0]=b0[0]; out_blk[1]=b0[1]; 
   out_blk[2]=b0[2]; out_blk[3]=b0[3]; 
 }


/*

 void main()
 {   int i, j;
  u4byte out_block[4], cipher_block[4];    
  const u4byte in_key[4]={0x11111111, 0x22222222, 0x33333333, 0x44444444}; 
  const u4byte plain_block[4]={0x12121212, 0x34343434, 0x45454545, 0x56565656};
 
  printf("----------------------\n");
  set_key(in_key, 128);

  encrypt(plain_block, cipher_block);
  printf("jiami =\n");
     for(i=0; i<4; i++) 
  printf("%x ", cipher_block[i]);   
 
  decrypt(cipher_block, out_block);
  printf("jiemi =\n");
     for(i=0; i<4; i++) 
  printf("%x ", out_block[i]);   
  printf("end\n");
 }
*/